﻿#define _CRT_SECURE_NO_WARNINGS 1
#include <stdio.h>

/* 1. 字符指针变量 */


//example 1
//int main()
//{
//	const char* pstr = "hello world!";
//	//将字符串首字符的地址放在 pstr 中
//	//该种方式是常量字符串 不能修改
//	char str[] = "hello world!";
//	char* p = str;
//	//数组是可以修改的
//	printf("%s\n", pstr);
//	printf("%s\n", str);
//	printf("*pstr = %c\n", *pstr);
//	printf("*str = %c\n", *p);
//	int sz = sizeof(str);
//	for (int i = 0; i < sz; i++)
//	{
//		printf("str[%d] = %c\n", i, str[i]);
//	}
//	//注意有一个 \0
//	return 0;
//}


//example 2
//int main()
//{
//	char str1[] = "hello bit.";
//	char str2[] = "hello bit.";
//	const char* str3 = "hello bit.";
//	const char* str4 = "hello bit.";
//	if (str1 == str2)
//		printf("str1 and str2 are same\n");
//	else
//		printf("str1 and str2 are not same\n");
//
//	if (str3 == str4)
//		printf("str3 and str4 are same\n");
//	else
//		printf("str3 and str4 are not same\n");
//	//str3 与 str4 是常量字符串 不可修改
//	//C/C++会将常量字符串存储单独的一个内存空间
//	//当指针指向同一个字符串时 会指向同一个内存空间
//	return 0;
//}



/* 2. 数组指针变量 */
/* 2.1 什么是数组指针变量 
* ！！！区分数组指针变量 和 指针数组
* 数组指针变量 是一种变量
* 用来存放数组的地址 是能够指向数组的指针变量
*/
//int* p1[10];  //指针数组、
// p1是指针数组，该数组每个元素都是一个指针，包含十个元素
//int (*p2)[10]; //数组指针
// p2是数组指针，指向数组，数组包含十个元素，每个元素的类型是 int
// [] 的优先级 高于 *


/* 2.2 初始化 */

//char arr[10] = { 0 };
//char(*p)[10] = &arr;
// p ——> 数组指针变量名
// char (*)[10] ——> 数组指针变量类型


/* 3. 二维数组传参的本质 */
// 二维数组可以看作元素是一维数组的数组
// 二维数组的数组名是第一行的地址，是"一维数组"的地址
// 形参可以写成数组的形式 也可以写成指针的形式
//void test(int a[3][5], int r, int c)
//{
//	int i = 0;
//	int j = 0;
//	for (i = 0; i < r; i++)
//	{
//		for (j = 0; j < c; j++)
//		{
//			printf("%d ", a[i][j]);
//		}
//		printf("\n");
//	}
//}
//
//void test1(int(*p)[5], int r, int c)
//{
//	int i = 0;
//	int j = 0;
//	for (i = 0; i < r; i++)
//	{
//		for (j = 0; j < c; j++)
//		{
//			printf("%d ", *(*(p + i) + j));
//			//先解引用 *(p+i)  --> 第 i 行的一维数组的首地址
//			//*(p+i)[j] == *(*(p+i)+j)
//			// + i 跳过 i 行
//		}
//		printf("\n");
//	}
//}
//
//int main()
//{
//	int arr[3][5] = { {1,2,3,4,5}, {2,3,4,5,6},{3,4,5,6,7} };
//	test(arr, 3, 5);
//	test1(arr, 3, 5);
//	return 0;
//}


/* 4. 函数指针变量 */
/*
* 函数指针变量 --> 存放函数地址的变量
* 函数名就是函数的地址 
*/

//void test()
//{
//	printf("hehe\n");
//}
//
//int main()
//{
//	printf("test: %p\n", test);
//	printf("&test: %p\n", &test);
//	//也可以通过 取地址操作符 & 来获得函数的地址
//	// test == &test 完全等价
//	return 0;
//}

//函数指针变量的定义和初始化 类比 数组指针变量
/*
void (*fp1)() = &test;
void (*fp2)() = test;

int (*pf3)(int x, int y)
类型 ： int (*)(int x, int y)
int : pf3指针指向函数返回类型
(*pf3)：函数指针变量名
(int x,int y):函数参数类型及个数
*/

//函数指针变量的使用
//int Add(int x, int y)
//{
//	return x + y;
//}
//int main()
//{
//	int(*pf3)(int, int) = Add;
//
//	printf("%d\n", (*pf3)(2, 3));
//	printf("%d\n", pf3(3, 5));
//	//可以解引用 * 也可以直接写地址
//	return 0;
//}


/*5. typedef 关键字*/
/*
* typedef 重命名类型，将复杂的类型简单化
*/
//
//typedef unsigned int uint;
////指针变量重定义
//typedef int* ptr_t;
////数组指针变量类型重新定义
////新的类型名字必须放在 * 右侧
//typedef (*new_type)[10];
////函数指针变量类型重新定义
////同理数组指针
//typedef void(*new_type_f)(int);
////简化以下代码
//void (*signal(int, void(*)(int)))(int);
//new_type_f signal(int, new_type_f);


//typedef 和 #define 的区别
//typedef int* ptr;
//#define PTR int*
//
//ptr p1, p2; //p1,p2是指针
//// typedef 是一个完整的类型
//PTR P3, P4;//p3是指针 p4是整型
// 编译器直接将 PTR 替换为int*
// int *p3,p4 
// *只能指示p3



/* 6. 函数指针数组 */
/*
* 存储相同类型函数指针的数组
*/
//定义
//int(*parr1[3])();
//char* (*pfArr[5])(int, char*);
//char* (*(*p)[4])(int, char*) = &pfArr;
//指向函数指针数组的指针...
//parr1[3] --> 表示是数组
//数组类型是函数指针 int(*)()



/* 7. 转移表 */
//计算器的一般实现
//int add(int a, int b)
//{
//	return a + b;
//}
//int sub(int a, int b)
//{
//	return a - b;
//}
//int mul(int a, int b)
//{
//	return a * b;
//}
//int div(int a, int b)
//{
//	return a / b;
//}
//int main()
//{
//	int x, y;
//	int input = 1;
//	int ret = 0;
//	do
//	{
//		printf("*************************\n");
//		printf(" 1:add 2:sub \n");
//		printf(" 3:mul 4:div \n");
//		printf(" 0:exit \n");
//		printf("*************************\n");
//		printf("请选择：");
//		scanf("%d", &input);
//		switch (input)
//		{
//		case 1:
//			printf("输⼊操作数：");
//			scanf("%d %d", &x, &y);
//			ret = add(x, y);
//			printf("ret = %d\n", ret);
//			break;
//		case 2:
//			printf("输⼊操作数：");
//			scanf("%d %d", &x, &y);
//			ret = sub(x, y);
//			printf("ret = %d\n", ret);
//			break;
//		case 3:
//			printf("输⼊操作数：");
//			scanf("%d %d", &x, &y);
//			ret = mul(x, y);
//			printf("ret = %d\n", ret);
//			break;
//		case 4:
//			printf("输⼊操作数：");
//			scanf("%d %d", &x, &y);
//			ret = div(x, y);
//			printf("ret = %d\n", ret);
//			break;
//		case 0:
//			printf("退出程序\n");
//			break;
//		default:
//			printf("选择错误\n");
//			break;
//		}
//	} while (input);
//	return 0;
//}


//使用函数指针组的实现

//int add(int a, int b)
//{
//	return a + b;
//}
//int sub(int a, int b)
//{
//	return a - b;
//}
//int mul(int a, int b)
//{
//	return a * b;
//}
//int div(int a, int b)
//{
//	return a / b;
//}
//int main()
//{
//	int x, y;
//	int input = 1;
//	int ret = 0;
//	//转移表
//	//实现类似于跳转的效果
//	//函数指针数组
//	int (*p[5])(int x, int y) = { 0,add,sub,mul,div };
//	do
//	{
//		printf("*************************\n");
//		printf(" 1:add 2:sub \n");
//		printf(" 3:mul 4:div \n");
//		printf(" 0:exit \n");
//		printf("*************************\n");
//		printf("请选择：");
//		scanf("%d", &input);
//		if (input <= 4 && input >= 1)
//		{
//			printf("请输入操作数: \n");
//			scanf("%d %d", &x, &y);
//			//调用函数
//			ret = p[input](x, y);
//			printf("ret = %d\n", ret);
//		}
//		else if (input == 0)
//		{
//			printf("计算器退出\n");
//		}
//		else
//			printf("错误输入，请重新输入：\n");
//	} while (input);
//	return 0;
//}
